home *** CD-ROM | disk | FTP | other *** search
/ Power Programmierung / Power-Programmierung (Tewi)(1994).iso / magazine / drdobbs / 1987 / 08 / shammlst.aug < prev    next >
Text File  |  1987-08-12  |  20KB  |  770 lines
  1.  
  2. Listing 1:  BASIC source code for the Sieve benchmark
  3.  
  4. 1000 ' Sieve Benchmark Test
  5. 1001 ' Version 1.0  5/30/86  Namir C. Shammas
  6. 1010 DEFINT A-Z
  7. 1020 SIZE = 7000
  8. 1030 MAXITER = 10
  9. 1040 TRUE = 1: FALSE = 0
  10. 1050 DIM  FLAGS(SIZE)
  11. 1060 PRINT "START ";MAXITER;" ITERATION"
  12. 1065 TIME$ = "00:00:00.00"
  13. 1070 FOR ITER = 1 TO MAXITER
  14. 1080    COUNT = 0
  15. 1090    FOR I = 0 TO SIZE
  16. 1100      FLAGS(I) = TRUE
  17. 1110    NEXT I
  18. 1120    FOR I = 0 TO SIZE
  19. 1130      IF FLAGS(I) <> TRUE THEN 1210
  20. 1140        PRIME = I+I+3
  21. 1150        K = I+PRIME
  22. 1160        WHILE K <= SIZE  
  23. 1170           FLAGS(K) = FALSE
  24. 1180           K = K + PRIME 
  25. 1190        WEND 
  26. 1200        COUNT = COUNT + 1
  27. 1210    NEXT I 
  28. 1220 NEXT ITER
  29. 1225 PRINT "Time is ";TIME$
  30. 1230 PRINT COUNT;" PRIMES"
  31. 1240 END 
  32.  
  33.  
  34.  
  35.  
  36. Listing 2: Translated C source code for the Sieve benchmark
  37.  
  38. char *TIME_(), *balloc(); 
  39. static int *FLAGS, count, false, i, iter, k, maxiter, prime, size, true; 
  40. static int it_1, it_2, it_3; 
  41. static char *st_1; 
  42. static int ml_1; 
  43. main(argc, argv) 
  44.     int argc; 
  45.     char *argv[]; 
  46.     { 
  47.     bio_init(argc, argv, 1); 
  48.     /* Sieve Benchmark Test */
  49.     /* Version 1.0  5/30/86  Namir C. Shammas */
  50.     size = 7000; 
  51.     maxiter = 10; 
  52.     true = 1; 
  53.     false = 0; 
  54.     ml_1 = size+1; 
  55.     bfree(FLAGS); 
  56.     FLAGS = (int*)balloc((long)sizeof(int) * (size+1)); 
  57.     BPRINT("s;i;s", "\006START ", maxiter, "\012 ITERATION"); 
  58.     STIME_("\01300:00:00.00"); 
  59.     it_1 = maxiter; 
  60.     
  61.     for (iter = 1; iter <= it_1; ++iter) 
  62. { 
  63.    count = 0; 
  64.    it_2 = size; 
  65.  
  66.    for (i = 0; i <= it_2; ++i) 
  67.    { 
  68.      FLAGS[i] = true; 
  69.    } 
  70.    it_3 = size; 
  71.  
  72.    for (i = 0; i <= it_3; ++i) 
  73.    { 
  74.      if (FLAGS[i] != true) 
  75.        goto l_1210; 
  76.      prime = i + i + 3; 
  77.      k = i + prime; 
  78.      while (k <= size) 
  79.      { 
  80.         FLAGS[k] = false; 
  81.         k = k + prime; 
  82.      } 
  83.      count = count + 1; 
  84.     
  85.      l_1210:; 
  86.     } 
  87. } 
  88.     BPRINT("s;s", "\010Time is ", TIME_(&st_1)); 
  89.     BPRINT("i;s", count, "\007 PRIMES"); 
  90.     bexit(0); 
  91.     bexit(0); 
  92. } 
  93.  
  94.  
  95.  
  96.  
  97. Listing 3: BASIC source code for a root-seeking program
  98.  
  99. 1010 DEFDBL A-H,P-Z
  100. 1020 DEFINT I-O
  101. 1030 DEF FNF(X) = EXP(X) - 3*X*X
  102. 1040 CLS
  103. 1050 INPUT "Enter guess : ";X : PRINT
  104. 1060 DATA 1.0E-08, 50
  105. 1070 READ Accuracy, MAX.ITER
  106. 1075 Iter = 0
  107. 1076 Diverge% = 1
  108. 1077 Diff = 2 * Accuracy
  109. 1078 WHILE ABS(Diff) > Accuracy
  110. 1080 ' Start root seeking method
  111. 1090   H = 0.01
  112. 1100   IF ABS(X) > 1 THEN H = H * X
  113. 1110   Diff = 2 * H * FNF(X) / (FNF(X+H) - FNF(X-H))
  114. 1120   X = X - Diff
  115. 1130   Iter = Iter + 1
  116. 1140   IF Iter > MAX.ITER THEN Diverge% = 0
  117. 1150 WEND
  118. 1155 IF (Diverge% = 0) THEN Accuracy = 10 * Accuracy : GOTO 1075
  119. 1160 PRINT USING "Root = +#.#######^^^^";X : PRINT
  120. 1170 PRINT USING "Number of iterations = ##";Iter : PRINT
  121. 1180 PRINT USING "Accuracy = #.###^^^^";Accuracy : PRINT
  122. 1190 END
  123.  
  124.  
  125.  
  126.  
  127. Listing 4: Translated C source code for a root-seeking program
  128.  
  129. typedef struct data 
  130.     { 
  131.     unsigned d_line; 
  132.     char *d_text; 
  133.     }DATA; 
  134. static DATA da_1[] = {1060, "1.0E-08, 50\n"}; 
  135. double ABS(), EXP(), f_raise(); 
  136. static int divergeI, iter, max_iter, n; 
  137. static double accuracy, diff, f, f0, f1, f2, h, x, x2; 
  138. DATA *data_stmts[] =  
  139.     { 
  140.     da_1, 0 
  141.     }; 
  142. main(argc, argv) 
  143.     int argc; 
  144.     char *argv[]; 
  145.     { 
  146.     bio_init(argc, argv, 1); 
  147.     CLS(); 
  148.     
  149. l_1040:; 
  150.     INPUT("P ;i", "\035Enter function number [1..3] ", &n); 
  151.     BPRINT(""); 
  152.      if (-((n < 1)) | -((n > 3))) 
  153.         goto l_1040; 
  154.     INPUT("P ;d", "\016Enter guess : ", &x); 
  155.     BPRINT(""); 
  156.     BREAD(" d,i", &accuracy, &max_iter); 
  157.     
  158. l_1075:; 
  159.     iter = 0; 
  160.     divergeI = 1; 
  161.     diff = 2 * accuracy; 
  162.     while (ABS(diff) > accuracy) 
  163.     { 
  164.     /* Start root seeking method */
  165.     h = 0.01; 
  166.      if (ABS(x) > 1) 
  167.         h = h * x; 
  168.     x2 = x; 
  169.     pr_1200(); 
  170.     f0 = f; 
  171.     x2 = x + h; 
  172.     pr_1200(); 
  173.     f1 = f; 
  174.     x2 = x - h; 
  175.     pr_1200(); 
  176.     f2 = f; 
  177.     diff = 2 * h * f0 / (f1 - f2); 
  178.     x = x - diff; 
  179.     iter = iter + 1; 
  180.      if (iter > max_iter) 
  181.         divergeI = 0; 
  182.     } 
  183.      if ((divergeI == 0)) 
  184.     { 
  185.     accuracy = 10 * accuracy; 
  186.     goto l_1075; 
  187.     } 
  188.     UPRINT("\025Root = +#.#######^^^^", "d", x); 
  189.     BPRINT(""); 
  190.     UPRINT("\032Number of iterations = ###", "i", iter); 
  191.     BPRINT(""); 
  192.     UPRINT("\024Accuracy = #.###^^^^", "d", accuracy); 
  193.     BPRINT(""); 
  194.     bexit(0); 
  195.     } 
  196.  
  197. pr_1200() 
  198.     { 
  199.     /* Subroutine to handle function catalogue */
  200.     switch (n) 
  201.     { 
  202.     case 1: 
  203.     pr_2100(); 
  204.     break; 
  205.     case 2: 
  206.     pr_2200(); 
  207.     break; 
  208.     case 3: 
  209.     pr_2300(); 
  210.     break; 
  211.     
  212.     } 
  213.     return; 
  214. /* Subroutine number 1 */
  215.         } 
  216.  
  217. pr_2100() 
  218.     { 
  219.     f = EXP(x2) - 3 * f_raise(x2, (double) 2); 
  220.     return; 
  221. /* Subroutine # 2 */
  222.         } 
  223.  
  224. pr_2200() 
  225.     { 
  226.     f = f_raise(x2, (double) 2) - 5 * x2 + 6; 
  227.     return; 
  228. /* Subroutine # 3 */
  229.         } 
  230.  
  231. pr_2300() 
  232.     { 
  233.     f = f_raise(x2, (double) 3) - 5 * x2 + 10; 
  234.     return; 
  235.     bexit(0); 
  236.     } 
  237.  
  238.  
  239.  
  240.  
  241. Listing 5: BASIC source code for Find/Replace utility.
  242.  
  243. 1000 ' Batch Find/Replace Utility  Version 1.1  2/7/86
  244. 1010 ' IBM PC                  BASICA version 2.0
  245. 1020 ' Copyright (c) 1987  Namir Clement Shammas
  246. 1030 '---------------------------------------------------
  247. 1040 OPTION BASE 1
  248. 1050 DEFINT A-Z
  249. 1060 DIM FILENAME$(20),FIND.STR$(30)
  250. 1070 DIM REPLACE.STR$(30),REPLACE.FLAG(30),TEXT.LINE$(500)
  251. 1080 '
  252. 1090 TRUE  = 1 : FALSE = 0 'Set true/false
  253. 1100 MAX.LINES = 500 ' Current maximum number of lines read from a file
  254. 1110 MAX.STRINGS = 30 ' Number of find/replace strings
  255. 1120 MAX.FILES = 20 ' Maximum number of files
  256. 1140 CLS
  257. 1150 '
  258. 1160 T$ = "BATCH FILE FIND/REPLACE PROGRAM" : GOSUB 2290
  259. 1170 T$ = "VERSION 1.0" : GOSUB 2290 : PRINT : PRINT
  260. 1180 GOSUB 1560 'GET.FILENAMES : Get filenames
  261. 1190 GOSUB 1820 'GET.STRINGS : Get search/replace strings
  262. 1200 FOR K = 1 TO NUM.FILES
  263. 1210   GOSUB 2060 ' READ.LINES: Read text lines from a file
  264. 1220   CHANGED = FALSE
  265. 1230   FOR I = 1 TO NUM.STRINGS
  266. 1240     FOUND = FALSE
  267. 1250     FOR J = 1 TO NUM.LINES
  268. 1260         PTR = INSTR(TEXT.LINE$(J),FIND.STR$(I))
  269. 1270         WHILE PTR > 0 
  270. 1280            IF (FOUND = TRUE) THEN 1330
  271. 1290               FOUND = TRUE
  272. 1300               LPRINT
  273. 1310               LPRINT "KEYWORD : ";FIND.STR$(I)
  274. 1330            LPRINT J;":";TEXT.LINE$(J)
  275. 1340            IF (REPLACE.FLAG(I) = FALSE) THEN 1440
  276. 1350                 CHANGED = TRUE
  277. 1360                 FIRST$ = ""
  278. 1370                 IF PTR > 1 THEN FIRST$ = MID$(TEXT.LINE$(J),1,(PTR-1))
  279. 1380                 LAST$ = ""
  280. 1390                 IF (PTR+LEN(FIND.STR$(I))) <= LEN(TEXT.LINE$(J))
  281.                                                             THEN 1420
  282. 1400                     LAST$ = MID$(TEXT.LINE$(J),(PTR+LEN(FIND.STR$(I))))
  283. 1420                 TEXT.LINE$(J) = FIRST$ + REPLACE.STR$(I) + LAST$
  284. 1440             PTR = INSTR(PTR+1,TEXT.LINE$(J),FIND.STR$(I))
  285. 1450        WEND
  286. 1460    NEXT J
  287. 1470  NEXT I
  288. 1480 IF (CHANGED = TRUE) THEN GOSUB 2190 ' WRITE.LINES
  289. 1490 NEXT K
  290. 1500 
  291. 1510 LPRINT CHR$(140) ' form feed
  292. 1520 
  293. 1530 END
  294. 1540 
  295. 1550 '--------------------------------------------------
  296. 1560 ' GET.FILENAMES:  Subroutine to input filenames from the keyboard
  297. 1570 NUM.FILES = 0
  298. 1580 WHILE (NUM.FILES <= 0) OR (NUM.FILES > MAX.FILES)
  299. 1590     INPUT "Enter number of files ";NUM.FILES
  300. 1600     PRINT 
  301. 1610 WEND
  302. 1620 FOR I = 1 TO NUM.FILES
  303. 1630 'REPEAT.LOOP1:
  304. 1640       PRINT "Enter filename # ";I;" ";
  305. 1650       INPUT FILENAME$(I) : PRINT
  306. 1660       ON ERROR GOTO 1750
  307. 1670       OPEN "I",1,FILENAME$(I)
  308. 1680       CLOSE #1
  309. 1690       ON ERROR GOTO 0
  310. 1700    IF FILENAME$(I) = "" THEN 1630
  311. 1710 NEXT I
  312. 1720 RETURN 
  313. 1740 '-------------------------------------------------
  314. 1750 'HANDLE: Error hander for bad filenames
  315. 1760 PRINT "File ";FILENAME$(I);" was not found"
  316. 1770 PRINT
  317. 1780 FILENAME$(I) = ""
  318. 1790 RESUME NEXT
  319. 1800 
  320. 1810 '--------------------------------------------------
  321. 1820 ' GET.STRINGS: Subroutines to input search/replace strings
  322. 1830 NUM.STRINGS = 0
  323. 1840 WHILE (NUM.STRINGS <= 0) OR (NUM.STRINGS > MAX.STRINGS)
  324. 1850     INPUT "Enter number of search/replace strings ";NUM.STRINGS
  325. 1860     PRINT 
  326. 1870 WEND
  327. 1880 FOR I = 1 TO NUM.STRINGS
  328. 1890     REPLACE.STR$(I) = ""
  329. 1900     PRINT : PRINT "For string # ";I
  330. 1910     INPUT "    Enter string ";FIND.STR$(I)
  331. 1920     INPUT "    R)eplace F)ind ";A$ : PRINT
  332. 1930     IF (INSTR("Rr",MID$(A$,1,1)) = 0) THEN REPLACE.FLAG(I) = 
  333.                                     FALSE ELSE REPLACE.FLAG(I) = TRUE
  334. 1980     IF REPLACE.FLAG(I) = FALSE THEN 2020
  335. 1990         INPUT "Enter replacement string ";REPLACE.STR$(I)
  336. 2000         PRINT
  337. 2020 NEXT I
  338. 2030 RETURN
  339. 2040 
  340. 2050 '--------------------------------------------------
  341. 2060 ' READ.LINES: Subroutines to read text lines
  342. 2070 LPRINT
  343. 2080 LPRINT "PROCESSING FILE : ";FILENAME$(K)
  344. 2090 OPEN "I",1,FILENAME$(K)
  345. 2100 NUM.LINES = 0
  346. 2110 WHILE (NOT EOF(1)) AND (NUM.LINES <= MAX.LINES)
  347. 2120    NUM.LINES = NUM.LINES + 1
  348. 2130    LINE INPUT #1,TEXT.LINE$(NUM.LINES)
  349. 2140 WEND
  350. 2150 CLOSE #1
  351. 2160 RETURN  
  352. 2180 '-------------------------------------------------
  353. 2190 ' WRITE.LINES: Subroutines to write text lines
  354. 2200 OPEN "O",1,FILENAME$(K)
  355. 2210 FOR I = 1 TO NUM.LINES
  356. 2220   PRINT #1,TEXT.LINE$(I)
  357. 2230 NEXT I
  358. 2240 CLOSE #1
  359. 2250 RETURN
  360. 2270 '--------------------------------------------------
  361. 2280 ' Subroutine to center a message
  362. 2290 PRINT SPC(40 - LEN(T$)\2);T$
  363. 2300 RETURN
  364.  
  365.  
  366.  
  367.  
  368. Listing 6: Translated C source code for Find/Replace utility.
  369.  
  370. extern int on_error, err_code, err_stmt, trap_line, trap_err; 
  371. char *CHR_(), *MID_(), *s_asgn(), *s_cat(); 
  372. int EOF(), INSTR(), LEN(); 
  373. static int AREPLACE_FLAG[31], changed, false, found, i, j, k, max_files; 
  374. static int max_lines, max_strings, num_files, num_lines, num_strings, ptr; 
  375. static int true; 
  376. static char *FILENAME_[21], *FIND_STR_[31], *REPLACE_STR_[31]; 
  377. static char *TEXT_LINE_[501], *a_, *first_, *last_, *t_; 
  378. static int it_1, it_2, it_3, it_4, it_5, it_6; 
  379. static char *st_1, *st_2; 
  380.  
  381. main(argc, argv) 
  382.     int argc; 
  383.     char *argv[]; 
  384.     { 
  385.     bio_init(argc, argv, 1); 
  386.     /* Batch Find/Replace Utility  Version 1.1  2/7/86 */
  387.     /* IBM PC                  BASICA version 2.0 */
  388.     /* Copyright (c) 1987  Namir Clement Shammas */
  389.     /* --------------------------------------------------- */
  390.     free_sp(FILENAME_, 21, 'S'); 
  391.     free_sp(FIND_STR_, 31, 'S'); 
  392.     free_sp(REPLACE_STR_, 31, 'S'); 
  393.     free_sp(TEXT_LINE_, 501, 'S'); 
  394.     
  395.     true = 1; 
  396.     false = 0; /* Set true/false */
  397.     max_lines = 500; /* Current maximum number of lines read from a file */
  398.     max_strings = 30; /* Number of find/replace strings */
  399.     max_files = 20; /* Maximum number of files */
  400.     CLS(); 
  401.     
  402.     t_ = s_asgn(t_, "\037BATCH FILE FIND/REPLACE PROGRAM"); 
  403.     sub_push(1); 
  404.     goto l_2290; 
  405. g_1:; 
  406.     t_ = s_asgn(t_, "\013VERSION 1.0"); 
  407.     sub_push(2); 
  408.     goto l_2290; 
  409. g_2:; 
  410. E_0:;
  411.     BPRINT(""); 
  412.     if (err_code) {err_stmt=0; goto err_trap;}
  413. E_1:;
  414.     BPRINT(""); 
  415.     if (err_code) {err_stmt=1; goto err_trap;}
  416. E_2:;
  417.     sub_push(3); /* GET.FILENAMES : Get filenames */
  418.     goto l_1560; 
  419. g_3:; 
  420.     sub_push(4); /* GET.STRINGS : Get search/replace strings */
  421.     goto l_1820; 
  422. g_4:; 
  423.     it_1 = num_files; 
  424.     
  425.     for (k = 1; k <= it_1; ++k) 
  426.     { 
  427.     sub_push(5); /* READ.LINES: Read text lines from a file */
  428.     goto l_2060; 
  429. g_5:; 
  430.     changed = false; 
  431.     it_2 = num_strings; 
  432.     
  433.     for (i = 1; i <= it_2; ++i) 
  434.         { 
  435.         found = false; 
  436.         it_3 = num_lines; 
  437.         
  438.         for (j = 1; j <= it_3; ++j) 
  439.         { 
  440. E_3:;
  441.         ptr = INSTR(-1, TEXT_LINE_[j], FIND_STR_[i]); 
  442.     if (err_code) {err_stmt=3; goto err_trap;}
  443. E_4:;
  444.         while (ptr > 0) 
  445.             { 
  446.              if ((found == true)) 
  447.             goto l_1330; 
  448.             found = true; 
  449. E_5:;
  450.             BLPRINT(""); 
  451.     if (err_code) {err_stmt=5; goto err_trap;}
  452. E_6:;
  453.             BLPRINT("s;s", "\012KEYWORD : ", FIND_STR_[i]); 
  454.     if (err_code) {err_stmt=6; goto err_trap;}
  455. E_7:;    
  456.  
  457. l_1330:; 
  458.             BLPRINT("i;s;s", j, "\001:", TEXT_LINE_[j]); 
  459.     if (err_code) {err_stmt=7; goto err_trap;}
  460. E_8:;
  461.              if ((AREPLACE_FLAG[i] == false)) 
  462.             goto l_1440; 
  463.             changed = true; 
  464.             first_ = s_asgn(first_, "\000"); 
  465.              if (ptr > 1) 
  466.             { 
  467. E_9:;
  468.             first_ = s_asgn(first_, MID_(&st_1, TEXT_LINE_[j],
  469.              1, (ptr - 1))); 
  470.     if (err_code) {err_stmt=9; goto err_trap;}
  471. E_10:;
  472.             } 
  473.             last_ = s_asgn(last_, "\000"); 
  474.              if ((ptr + LEN(FIND_STR_[i])) <= LEN(TEXT_LINE_[j])) 
  475.             goto l_1420; 
  476. E_11:;
  477.             last_ = s_asgn(last_, MID_(&st_1, TEXT_LINE_[j], (ptr
  478.              + LEN(FIND_STR_[i])), -1)); 
  479.     if (err_code) {err_stmt=11; goto err_trap;}
  480. E_12:;
  481.             
  482. l_1420:; 
  483.             TEXT_LINE_[j] = s_asgn(TEXT_LINE_[j], s_cat(&st_2, s
  484.                                                                 _cat(&st_1,
  485.              first_, REPLACE_STR_[i]), last_)); 
  486.     if (err_code) {err_stmt=12; goto err_trap;}
  487. E_13:;
  488.             
  489. l_1440:; 
  490.             ptr = INSTR(ptr + 1, TEXT_LINE_[j], FIND_STR_[i]); 
  491.     if (err_code) {err_stmt=13; goto err_trap;}
  492. E_14:;
  493.             } 
  494.         } 
  495.         } 
  496.      if ((changed == true)) 
  497.         { /* WRITE.LINES */
  498.         sub_push(6); /* WRITE.LINES */
  499.         goto l_2190; 
  500. g_6:; 
  501.         } 
  502.     } 
  503. E_15:;
  504.     BLPRINT("s", CHR_(&st_1, 140)); /* form feed */
  505.     if (err_code) {err_stmt=15; goto err_trap;}
  506. E_16:;
  507.         bexit(0); 
  508. /* -------------------------------------------------- */
  509.     
  510. l_1560:; 
  511.     /* GET.FILENAMES:  Subroutine to input filenames from the keyboard */
  512.     num_files = 0; 
  513.     while (-((num_files <= 0)) | -((num_files > max_files))) 
  514.     { 
  515. E_17:;
  516.     INPUT("P ;i", "\026Enter number of files ", &num_files); 
  517.     if (err_code) {err_stmt=17; goto err_trap;}
  518. E_18:;
  519.         BPRINT(""); 
  520.     if (err_code) {err_stmt=18; goto err_trap;}
  521. E_19:;
  522.     } 
  523.     it_4 = num_files; 
  524.     
  525.     for (i = 1; i <= it_4; ++i) 
  526.     { 
  527.     
  528. l_1630:; 
  529.     /* REPEAT.LOOP1: */
  530. E_20:;
  531.     BPRINT("s;i;s;", "\021Enter filename # ", i, "\001 "); 
  532.     if (err_code) {err_stmt=20; goto err_trap;}
  533. E_21:;
  534.         INPUT(" s", &FILENAME_[i]); 
  535.     if (err_code) {err_stmt=21; goto err_trap;}
  536. E_22:;
  537.         BPRINT(""); 
  538.     if (err_code) {err_stmt=22; goto err_trap;}
  539. E_23:;
  540.     on_error = 1; 
  541.     err_code = 0; 
  542.     trap_line = 1; 
  543. E_24:;
  544.     BOPEN("\001I", 1, FILENAME_[i], -1); 
  545.     if (err_code) {err_stmt=24; goto err_trap;}
  546. E_25:;
  547.         BCLOSE(1, 0); 
  548.     if (trap_err) 
  549.         { 
  550.         xer_msg(trap_err); 
  551.         bexit(1); 
  552.         } 
  553.     on_error = 0; 
  554.     err_code = 0; 
  555.      if (s_comp(FILENAME_[i], "\000") == 0) 
  556.         goto l_1630; 
  557.     } 
  558.     goto sub_ret; 
  559. /* ------------------------------------------------- */
  560.  
  561. l_1750:; 
  562.     /* HANDLE: Error hander for bad filenames */
  563. E_26:;
  564.     BPRINT("s;s;s", "\005File ", FILENAME_[i], "\016 was not found"); 
  565.     if (err_code) {err_stmt=26; goto err_trap;}
  566. E_27:;
  567.     BPRINT(""); 
  568.     if (err_code) {err_stmt=27; goto err_trap;}
  569. E_28:;
  570.     FILENAME_[i] = s_asgn(FILENAME_[i], "\000"); 
  571.     ++err_stmt; 
  572.     goto un_trap; 
  573. /* -------------------------------------------------- */
  574.     
  575. l_1820:; 
  576.     /* GET.STRINGS: Subroutines to input search/replace strings */
  577.     num_strings = 0; 
  578.     while (-((num_strings <= 0)) | -((num_strings > max_strings))) 
  579.     { 
  580. E_29:;
  581.     INPUT("P ;i", "\047Enter number of search/replace strings ",
  582.                                                     &num_strings); 
  583.     if (err_code) {err_stmt=29; goto err_trap;}
  584. E_30:;
  585.     BPRINT(""); 
  586.     if (err_code) {err_stmt=30; goto err_trap;}
  587. E_31:;
  588.         } 
  589.     it_5 = num_strings; 
  590.     
  591.     for (i = 1; i <= it_5; ++i) 
  592.     { 
  593.     REPLACE_STR_[i] = s_asgn(REPLACE_STR_[i], "\000"); 
  594. E_32:;
  595.     BPRINT(""); 
  596.     if (err_code) {err_stmt=32; goto err_trap;}
  597. E_33:;
  598.     BPRINT("s;i", "\015For string # ", i); 
  599.     if (err_code) {err_stmt=33; goto err_trap;}
  600. E_34:;
  601.     INPUT("P ;s", "\021    Enter string ", &FIND_STR_[i]); 
  602.     if (err_code) {err_stmt=34; goto err_trap;}
  603. E_35:;
  604.     INPUT("P ;s", "\023    R)eplace F)ind ", &a_); 
  605.     if (err_code) {err_stmt=35; goto err_trap;}
  606. E_36:;
  607.     BPRINT(""); 
  608.     if (err_code) {err_stmt=36; goto err_trap;}
  609. E_37:;
  610.          if ((INSTR(-1, "\002Rr", MID_(&st_1, a_, 1, 1)) == 0)) 
  611.         { 
  612.         AREPLACE_FLAG[i] = false; 
  613.         } 
  614.      else 
  615.         { 
  616.         AREPLACE_FLAG[i] = true; 
  617.         } 
  618.      if (AREPLACE_FLAG[i] == false) 
  619.         goto l_2020; 
  620. E_38:;
  621.     INPUT("P ;s", "\031Enter replacement string ", &REPLACE_STR_[i]); 
  622.     if (err_code) {err_stmt=38; goto err_trap;}
  623. E_39:;
  624.     BPRINT(""); 
  625.     if (err_code) {err_stmt=39; goto err_trap;}
  626. E_40:;
  627.  
  628. l_2020:; 
  629.     } 
  630.     goto sub_ret; 
  631. /* -------------------------------------------------- */
  632.     
  633. l_2060:; 
  634.     /* READ.LINES: Subroutines to read text lines */
  635. E_41:;
  636.     BLPRINT(""); 
  637.     if (err_code) {err_stmt=41; goto err_trap;}
  638. E_42:;
  639.     BLPRINT("s;s", "\022PROCESSING FILE : ", FILENAME_[k]); 
  640.     if (err_code) {err_stmt=42; goto err_trap;}
  641. E_43:;
  642.     BOPEN("\001I", 1, FILENAME_[k], -1); 
  643.     if (err_code) {err_stmt=43; goto err_trap;}
  644. E_44:;
  645.         num_lines = 0; 
  646.     while ((~(EOF(1))) & -((num_lines <= max_lines))) 
  647.     { 
  648.     num_lines = num_lines + 1; 
  649. E_45:;
  650.     INPUT("FLl", 1, &TEXT_LINE_[num_lines]); 
  651.     if (err_code) {err_stmt=45; goto err_trap;}
  652. E_46:;
  653.         } 
  654.     BCLOSE(1, 0); 
  655.     goto sub_ret; 
  656. /* ------------------------------------------------- */
  657.     
  658. l_2190:; 
  659.     /* WRITE.LINES: Subroutines to write text lines */
  660. E_47:;
  661.     BOPEN("\001O", 1, FILENAME_[k], -1); 
  662.     if (err_code) {err_stmt=47; goto err_trap;}
  663. E_48:;
  664.     it_6 = num_lines; 
  665.     
  666.     for (i = 1; i <= it_6; ++i) 
  667.     { 
  668. E_49:;
  669.     BFPRINT(1, "s", TEXT_LINE_[i]); 
  670.     if (err_code) {err_stmt=49; goto err_trap;}
  671. E_50:;    } 
  672.     BCLOSE(1, 0); 
  673.     goto sub_ret; 
  674. /* -------------------------------------------------- */
  675.     /* Subroutine to center a message */
  676. E_51:;
  677.  
  678. l_2290:; 
  679.     BPRINT("b;s", 40 - LEN(t_) / 2, t_); 
  680.     if (err_code) {err_stmt=51; goto err_trap;}
  681. E_52:;
  682.     goto sub_ret; 
  683.     bexit(0); 
  684.  
  685.     sub_ret: 
  686.     switch(sub_pop())  
  687.     { 
  688.     case 1: goto g_1; 
  689.     case 2: goto g_2; 
  690.     case 3: goto g_3; 
  691.     case 4: goto g_4; 
  692.     case 5: goto g_5; 
  693.     case 6: goto g_6; 
  694.     } 
  695.     
  696. err_trap: if (trap_err) 
  697.     { 
  698.     xer_msg(err_code); 
  699.     bexit(1); 
  700.     } 
  701.     trap_err = err_code; 
  702.     err_code = 0; 
  703.     goto l_1750; 
  704.     
  705. un_trap: if (!trap_err) 
  706.     { 
  707.     xer_msg(-99); 
  708.     bexit(1); 
  709.     } 
  710.     trap_err = err_code = 0; 
  711.     switch(err_stmt) 
  712.     { 
  713.     case 0: goto E_0; 
  714.     case 1: goto E_1; 
  715.     case 2: goto E_2; 
  716.     case 3: goto E_3; 
  717.     case 4: goto E_4; 
  718.     case 5: goto E_5; 
  719.     case 6: goto E_6; 
  720.     case 7: goto E_7; 
  721.     case 8: goto E_8; 
  722.     case 9: goto E_9; 
  723.     case 10: goto E_10; 
  724.     case 11: goto E_11; 
  725.     case 12: goto E_12; 
  726.     case 13: goto E_13; 
  727.     case 14: goto E_14; 
  728.     case 15: goto E_15; 
  729.     case 16: goto E_16; 
  730.     case 17: goto E_17; 
  731.     case 18: goto E_18; 
  732.     case 19: goto E_19; 
  733.     case 20: goto E_20; 
  734.     case 21: goto E_21; 
  735.     case 22: goto E_22; 
  736.     case 23: goto E_23; 
  737.     case 24: goto E_24; 
  738.     case 25: goto E_25; 
  739.     case 26: goto E_26; 
  740.     case 27: goto E_27; 
  741.     case 28: goto E_28; 
  742.     case 29: goto E_29; 
  743.     case 30: goto E_30; 
  744.     case 31: goto E_31; 
  745.     case 32: goto E_32; 
  746.     case 33: goto E_33; 
  747.     case 34: goto E_34; 
  748.     case 35: goto E_35; 
  749.     case 36: goto E_36; 
  750.     case 37: goto E_37; 
  751.     case 38: goto E_38; 
  752.     case 39: goto E_39; 
  753.     case 40: goto E_40; 
  754.     case 41: goto E_41; 
  755.     case 42: goto E_42; 
  756.     case 43: goto E_43; 
  757.     case 44: goto E_44; 
  758.     case 45: goto E_45; 
  759.     case 46: goto E_46; 
  760.     case 47: goto E_47; 
  761.     case 48: goto E_48; 
  762.     case 49: goto E_49; 
  763.     case 50: goto E_50; 
  764.     case 51: goto E_51; 
  765.     case 52: goto E_52; 
  766.     } 
  767.     } 
  768.  
  769.  
  770.